package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/smart-snapshotter/pkg/cache"
)

func main() {
	fmt.Println("=== 智能缓存管理系统演示 ===")

	// 演示1: LRU缓存
	fmt.Println("\n1. LRU缓存演示")
	demoLRUCache()

	// 演示2: LFU缓存
	fmt.Println("\n2. LFU缓存演示")
	demoLFUCache()

	// 演示3: 混合缓存
	fmt.Println("\n3. 混合缓存演示")
	demoHybridCache()

	// 演示4: 缓存预热
	fmt.Println("\n4. 缓存预热演示")
	demoCacheWarming()

	// 演示5: 缓存一致性
	fmt.Println("\n5. 缓存一致性演示")
	demoConsistency()

	fmt.Println("\n=== 演示完成 ===")
}

func demoLRUCache() {
	config := cache.Config{
		Type:     "lru",
		MaxSize:  1024 * 1024, // 1MB
		TTL:      3600,
		Strategy: "lru",
	}

	lruCache, err := cache.NewLRUCache(config)
	if err != nil {
		log.Printf("创建LRU缓存失败: %v", err)
		return
	}

	ctx := context.Background()

	// 添加一些数据
	for i := 0; i < 5; i++ {
		key := fmt.Sprintf("file_%d.txt", i)
		value := []byte(fmt.Sprintf("内容 %d", i))
		if err := lruCache.Set(ctx, key, value, time.Hour); err != nil {
			log.Printf("设置缓存失败: %v", err)
			continue
		}
		fmt.Printf("  缓存添加: %s\n", key)
	}

	// 访问数据
	for i := 0; i < 3; i++ {
		key := fmt.Sprintf("file_%d.txt", i)
		if data, err := lruCache.Get(ctx, key); err == nil {
			fmt.Printf("  缓存命中: %s -> %s\n", key, string(data))
		}
	}

	// 显示统计信息
	if stats, err := lruCache.GetStats(ctx); err == nil {
		fmt.Printf("  统计信息: 命中=%d, 未命中=%d, 命中率=%.2f%%\n",
			stats.Hits, stats.Misses, stats.HitRatio*100)
	}
}

func demoLFUCache() {
	config := cache.Config{
		Type:     "lfu",
		MaxSize:  1024 * 1024, // 1MB
		TTL:      3600,
		Strategy: "lfu",
	}

	lfuCache, err := cache.NewLFUCache(config)
	if err != nil {
		log.Printf("创建LFU缓存失败: %v", err)
		return
	}

	ctx := context.Background()

	// 添加数据
	for i := 0; i < 3; i++ {
		key := fmt.Sprintf("data_%d", i)
		value := []byte(fmt.Sprintf("数据 %d", i))
		if err := lfuCache.Set(ctx, key, value, time.Hour); err != nil {
			log.Printf("设置缓存失败: %v", err)
			continue
		}
	}

	// 频繁访问某些数据
	for i := 0; i < 5; i++ {
		if _, err := lfuCache.Get(ctx, "data_0"); err == nil {
			fmt.Printf("  访问 data_0 (第%d次)\n", i+1)
		}
	}

	// 显示频率分布
	if freqDist := lfuCache.GetFrequencyDistribution(); len(freqDist) > 0 {
		fmt.Printf("  频率分布: %v\n", freqDist)
	}
}

func demoHybridCache() {
	config := cache.Config{
		Type:     "hybrid",
		MaxSize:  10 * 1024 * 1024, // 10MB
		TTL:      3600,
		Strategy: "lru",
	}

	hybridCache, err := cache.NewHybridCache(config)
	if err != nil {
		log.Printf("创建混合缓存失败: %v", err)
		return
	}

	ctx := context.Background()

	// 添加数据到混合缓存
	for i := 0; i < 5; i++ {
		key := fmt.Sprintf("hybrid_%d", i)
		value := []byte(fmt.Sprintf("混合数据 %d", i))
		if err := hybridCache.Set(ctx, key, value, time.Hour); err != nil {
			log.Printf("设置混合缓存失败: %v", err)
			continue
		}
	}

	// 等待异步写入磁盘
	time.Sleep(100 * time.Millisecond)

	// 访问数据（应该命中内存缓存）
	for i := 0; i < 3; i++ {
		key := fmt.Sprintf("hybrid_%d", i)
		if data, err := hybridCache.Get(ctx, key); err == nil {
			fmt.Printf("  混合缓存命中: %s -> %s\n", key, string(data))
		}
	}

	// 显示分层统计
	tierStats := hybridCache.GetTierStats()
	fmt.Printf("  内存层: 命中=%d, 容量=%.2fMB\n",
		tierStats["memory"].(map[string]interface{})["hits"].(int64),
		float64(tierStats["memory"].(map[string]interface{})["capacity"].(int64))/(1024*1024))
	fmt.Printf("  磁盘层: 命中=%d, 容量=%.2fMB\n",
		tierStats["disk"].(map[string]interface{})["hits"].(int64),
		float64(tierStats["disk"].(map[string]interface{})["capacity"].(int64))/(1024*1024))
}

func demoCacheWarming() {
	// 创建内存缓存
	config := cache.Config{
		Type:     "memory",
		MaxSize:  1024 * 1024, // 1MB
		TTL:      3600,
		Strategy: "lru",
	}

	memCache, err := cache.NewMemoryCache(config)
	if err != nil {
		log.Printf("创建内存缓存失败: %v", err)
		return
	}

	// 创建预取管理器
	prefetchConfig := cache.PrefetchConfig{
		Enabled:       true,
		MaxWorkers:    4,
		BatchSize:     10,
		Timeout:       30 * time.Second,
		RetryAttempts: 3,
		RetryDelay:    1 * time.Second,
	}

	prefetchManager, err := cache.NewPrefetchManager(memCache, prefetchConfig)
	if err != nil {
		log.Printf("创建预取管理器失败: %v", err)
		return
	}

	ctx := context.Background()

	// 模拟需要预取的关键数据
	warmupKeys := []string{
		"/etc/passwd",
		"/etc/hosts",
		"/bin/sh",
		"/lib/libc.so.6",
		"/usr/bin/python3",
	}

	fmt.Println("  开始缓存预热...")
	if err := prefetchManager.WarmCache(ctx, warmupKeys); err != nil {
		log.Printf("缓存预热失败: %v", err)
		return
	}

	// 等待预热完成
	time.Sleep(2 * time.Second)

	// 显示预取统计
	stats := prefetchManager.GetStats()
	fmt.Printf("  预热完成: 总任务=%d, 完成=%d, 失败=%d\n",
		stats.TotalJobs, stats.CompletedJobs, stats.FailedJobs)

	// 分析访问模式
	recentKeys := []string{"/bin/sh", "/bin/sh", "/etc/passwd", "/etc/passwd", "/etc/passwd"}
	suggestedKeys := prefetchManager.AnalyzeAccessPattern(recentKeys)
	if len(suggestedKeys) > 0 {
		fmt.Printf("  建议预取: %v\n", suggestedKeys)
	}
}

func demoConsistency() {
	// 创建内存缓存
	config := cache.Config{
		Type:     "memory",
		MaxSize:  1024 * 1024, // 1MB
		TTL:      3600,
		Strategy: "lru",
	}

	memCache, err := cache.NewMemoryCache(config)
	if err != nil {
		log.Printf("创建内存缓存失败: %v", err)
		return
	}

	// 创建一致性管理器
	consistencyConfig := cache.ConsistencyConfig{
		Enabled:           true,
		CheckInterval:     1 * time.Minute,
		ChecksumAlgorithm: "sha256",
		AutoRepair:        true,
		ValidationMode:    "relaxed",
		MaxAge:            24 * time.Hour,
		CleanupInterval:   1 * time.Hour,
	}

	consistencyManager, err := cache.NewConsistencyManager(memCache, consistencyConfig)
	if err != nil {
		log.Printf("创建一致性管理器失败: %v", err)
		return
	}

	ctx := context.Background()

	// 添加一些数据
	testData := map[string]string{
		"config.json": `{"version": "1.0", "debug": true}`,
		"app.log":     "Application started successfully",
		"data.bin":    "Binary data content",
	}

	for key, value := range testData {
		if err := memCache.Set(ctx, key, []byte(value), time.Hour); err != nil {
			log.Printf("设置缓存失败: %v", err)
			continue
		}
		fmt.Printf("  添加数据: %s\n", key)
	}

	// 验证数据一致性
	fmt.Println("  验证数据一致性...")
	for key := range testData {
		result, err := consistencyManager.ValidateEntry(ctx, key)
		if err != nil {
			log.Printf("验证失败: %v", err)
			continue
		}
		if result.Valid {
			fmt.Printf("  ✓ %s: 有效\n", key)
		} else {
			fmt.Printf("  ✗ %s: %s\n", key, result.Issue)
		}
	}

	// 显示一致性报告
	report := consistencyManager.GetConsistencyReport()
	fmt.Printf("  一致性报告: 总条目=%d, 有效=%d, 无效=%d\n",
		report["total_entries"].(int), report["valid_entries"].(int), report["invalid_entries"].(int))
}